package com.example.demo.practice;

import org.junit.jupiter.api.Test;

import java.util.concurrent.locks.LockSupport;

/**
 * @author liweizhi
 * @date 2020/5/7
 * 关于String,注意一下几点:
 * 1. 每次new String("xx")都会在堆中创建一个"xx"对象,然后在常量池中也创建一个对象,这俩不是同一个对象
 * 2. String a = "xx"; 会检查常量池中有没有"xx"对象,如果有直接返回;如果没有则只在常量池中创建一个"xx"对象,然后返回
 * 3. String.intern()方法,会返回常量池中的"xx"对象,如果常量池已有则直接返回;如果没有,就把堆中的对象放入常量池,他俩是同一个对象,然后返回.
 * 4. 字符串变量的相加,设String a = "aa", String s = "ss"; final String q = "qq", final String w = "ww";
 *    如果两者都是直接字符串,如String x = "aa" + "ss",编译器会直接优化成String a = "aass";
 *    如果两者都是final变量,如String x = q + w, 编译器会直接优化成String a = "qqww";
 *    其他情况下,即,如果是两者有一个是非final的变量,如a + b,或者a+"ss",其实会编译成new StringBuilder.append().append().toString()
 */
public class StringTest {
    @Test
    public void test0(){
        String h = new String("cc");
        String intern = h.intern();
        // false, 堆中的和常量池中的不是同一个
        System.out.println(intern == h);
    }

    @Test
    public void test1() {
        // 每次new String("xx")都会在堆中创建一个"xx"对象,然后在常量池中也创建一个对象
        // 字符串的相加,其实是StringBuilder的append
        String str2 = new String("str") + new String("01");
        // 会直接在常量池创建一个"str01"
        String str1 = "str01";
        // 此时常量池已经有"str01"了
        str2.intern();
        // false
        System.out.println(str2 == str1);
    }

    @Test
    public void test2() {
        String str2 = new String("str") + new String("01");
        // 此时常量池没有"str01",会把str2放入常量池;然后返回str2,尽管没有人接收
        str2.intern();
        // 直接返回常量池中的str2
        String str1 = "str01";
        // true
        System.out.println(str2 == str1);
    }


    @Test
    public void test3() {
        String s1 = "abc";
        String s2 = "a";
        String s3 = "bc";
        // s4是一个新的StringBuilder.toString()对象,不是从池子中拿的
        String s4 = s2 + s3;
        System.out.println(s1 == s4);//false
    }

    @Test
    public void test4() {
        String S1 = "abc";
        final String S2 = "a";
        final String S3 = "bc";
        String S4 = S2 + S3;
        System.out.println(S1 == S4);//true
    }

    @Test
    public void test5() {
        String str1 = "abcd";
        // 会直接编译成 String str3 = "abcd";
        String str3 = "ab" + "cd";
        System.out.println(str1 == str3 ); //true
    }

    @Test
    public void test6() {
        String str1 = "abcd";
        String str4 = "ab";
        // 反编译后是str4 = str4 + "cd"; 但是用工具查看其字节码,还是创建了StringBuilder
        str4 += "cd";
        System.out.println(str1 == str4); // false
    }
    @Test
    public void test7() {
        String str1 = "abcd";
        String str4 = "ab";
        final String c = "cd";
        // 反编译后仍是str4 = str4 + "cd";
        str4 += c;
        System.out.println(str1 == str4); // false
    }

    @Test
    public void test8() {
        String str1 = "abcd";
        String str4 = "ab";
        String c = "cd";
        // 反编译后是str4 = str4 + c;
        str4 += c;
        System.out.println(str1 == str4); // false
    }

    public static void main(String[] args) {
        LockSupport.park();
    }
}
